package mpbe.estructura.secciones.hormigon_armado;

/*
 * Este codigo es software libre y se encuentra licenciado 
 * bajo los términos de la Licencia Pública General de GNU versión 3 
 * según se encuentra publicada por la Free Software Foundation.
 * http://www.gnu.org/licenses/gpl.html
 * 
 * Autor: Martin Pablo Bellanca <martin.bellanca@gmail.com>
 * web: http://mpbe.blogspot.com/
 */

import java.util.Iterator;
import java.util.Vector;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;

import mpbe.estructura.secciones.hormigon_armado.contornos.SHContorno;

public class SHGrupos {
	private Vector<SHGrupo_de_Barras> grupos;
	private boolean guardar;
	private boolean recalcular;
	
	
	//-------------------------------------
	// Constructores
	//-------------------------------------
	public SHGrupos() {
		grupos = new Vector<SHGrupo_de_Barras>();
		grupos.add(new SHGrupo_de_Barras("Grupo 1", true));
		guardar = true;
		recalcular = true;
	}
	
	
	//-------------------------------------
	// Propiedades de la seccion
	//-------------------------------------
	public double getArea_Barras() {
		double area = 0;
		Iterator<SHGrupo_de_Barras> iter = grupos.iterator();
		SHGrupo_de_Barras gb = new SHGrupo_de_Barras();
		while (iter.hasNext()) {
			gb = (SHGrupo_de_Barras) iter.next();
			area += gb.getArea();
		}
		return area;
	}
	
	public double getArea_Grupo(int id) {
		double area = 0;
		if (id < grupos.size()) {
			SHGrupo_de_Barras gb = grupos.get(id);
			area = gb.getArea();
		}
		return area;
	}

	//-------------------------------------
	// delegados de Guargar y recalcular
	//-------------------------------------
	public boolean isGuardar() {
		return guardar;
	}

	public void setGuardar(boolean guardar) {
		this.guardar = guardar;
	}

	public boolean isRecalcular() {
		return recalcular;
	}

	public void setRecalcular(boolean recalcular) {
		this.recalcular = recalcular;
	}
	
	
	//**********************************
	// Funciones de modificacion
	//**********************************
	public void mod_InvertirV(){
		// invierte barras
		if (grupos!=null) {
			SHGrupo_de_Barras GB;
			for (int gg=0; gg<grupos.size(); gg++){
				GB = grupos.get(gg);
				GB.mod_InvetirV();
			}
		}
	}
	
	public void mover(double deltaX, double deltaY) {
		SHGrupo_de_Barras GB;
		for (int gg=0; gg<grupos.size(); gg++){
			GB = grupos.get(gg);
			GB.mover(deltaX, deltaY);
		}
		
	}
	
	public void rotar(double grados){
		double rad, l;
		double delta = grados*Math.PI/180;
		// barras
		SHGrupo_de_Barras GB;
		for (int gg=0; gg<grupos.size(); gg++){
			GB = grupos.get(gg);
			GB.rotar(grados);
		}
	}
	
	
	//*****************************************************
	// Funciones JSON
	//*****************************************************
	public void put_JSON(JSONArray ja){
		JSONObject joa = new JSONObject();	
		grupos.clear();
		SHGrupo_de_Barras gg;
		for (int ii=0; ii<ja.size(); ii++) {
			joa = (JSONObject) ja.get(ii);
			gg = new SHGrupo_de_Barras();
			gg.put_JSON(joa);
			grupos.add(gg);
		}
	}
	public JSONArray get_JSONArray() {		
		JSONArray ja = new JSONArray();
		SHGrupo_de_Barras gg = new SHGrupo_de_Barras();
		for (int ii=0; ii<grupos.size(); ii++) {
			gg = grupos.get(ii);
			ja.add(gg.get_JSONObject());
		}
		return ja;
	}
	public String get_JSONString(int tab) {
		String res = tabs(tab+1)+"[\n";
		SHGrupo_de_Barras gb = new SHGrupo_de_Barras();
		for (int ii=0; ii<grupos.size(); ii++) {
			gb = grupos.get(ii);
			res += gb.get_JSONString(tab+2);
			if (ii==grupos.size()-1) res += "\n"+tabs(tab+1)+"],\n"; else res += ",\n";
		}
		return res;
	}
	
	private String tabs(int can) {
		String str = new String();
		for (int ii=0; ii<can; ii++) str += "   "; // \t
		return str;
	}
	
	
	//------------------------------------
	// delegados de Grupos
	//-------------------------------------
	public void add(int index, SHGrupo_de_Barras element) {
		grupos.add(index, element);
		guardar = true;
		recalcular = true;
	}

	public boolean add(SHGrupo_de_Barras e) {
		guardar = true;
		recalcular = true;
		return grupos.add(e);
	}

	public int capacity() {
		return grupos.capacity();
	}

	public void clear() {
		grupos.clear();
		guardar = true;
		recalcular = true;
	}

	public Object clone() {
		return grupos.clone();
	}

	public void copyInto(Vector <SHGrupo_de_Barras> grupos)
	{
		grupos.clear();
		Iterator<SHGrupo_de_Barras> it = this.grupos.iterator();
		SHGrupo_de_Barras gb;
		while (it.hasNext()) {
			gb = new SHGrupo_de_Barras();
			it.next().copyInto(gb);
			grupos.add(gb);
		} ;

	}
	
	public SHGrupo_de_Barras firstElement() {
		return grupos.firstElement();
	}

	/**
	 * @return
	 * @uml.property  name="grupos"
	 */
	public Vector<SHGrupo_de_Barras>getGrupos() {
		return grupos;
	}
	
	public SHGrupo_de_Barras get(int index) {
		return grupos.get(index);
	}

	public int indexOf(Object o, int index) {
		return grupos.indexOf(o, index);
	}

	public int indexOf(Object o) {
		return grupos.indexOf(o);
	}

	public boolean isEmpty() {
		return grupos.isEmpty();
	}

	public Iterator<SHGrupo_de_Barras> iterator() {
		return grupos.iterator();
	}

	public SHGrupo_de_Barras lastElement() {
		return grupos.lastElement();
	}

	public int lastIndexOf(Object o, int index) {
		return grupos.lastIndexOf(o, index);
	}

	public int lastIndexOf(Object o) {
		return grupos.lastIndexOf(o);
	}

	public SHGrupo_de_Barras remove(int index) {
		guardar = true;
		recalcular = true;
		return grupos.remove(index);
	}

	public boolean remove(Object o) {
		guardar = true;
		recalcular = true;
		return grupos.remove(o);
	}

	public SHGrupo_de_Barras set(int index, SHGrupo_de_Barras element) {
		guardar = true;
		recalcular = true;
		return grupos.set(index, element);
	}

	public void setSize(int newSize) {
		grupos.setSize(newSize);
	}

	public int size() {
		return grupos.size();
	}

	public String toString() {
		return grupos.toString();
	}
	
}
